/**
 * 生成用户数据，包括代理商和分销商的佣金和订单相关数据
 * @param count 生成用户的数量
 * @param type 可选的用户类型筛选('all', 'agent', 'distributor', 'normal')
 * @returns 用户数据数组
 */
export function generateUsersData(count: number = 20, type: string = 'all') {
  const users = [];
  
  // 用户角色列表
  const roles = ['管理员', '分销商', '普通用户'];
  
  // 根据type筛选要生成的角色
  let filteredRoles = roles;
  if (type === 'agent') {
    filteredRoles = ['管理员'];
  } else if (type === 'distributor') {
    filteredRoles = ['分销商'];
  } else if (type === 'normal') {
    filteredRoles = ['普通用户'];
  }
  
  // 头像基本URL
  const avatarBaseUrl = 'https://randomuser.me/api/portraits/';
  
  for (let i = 0; i < count; i++) {
    // 随机选择用户角色
    const role = filteredRoles[Math.floor(Math.random() * filteredRoles.length)];
    
    // 生成姓名
    const name = `用户${i + 1}`;
    
    // 生成电话号码
    const phone = '1' + Math.floor(Math.random() * 7 + 3) + Array(9).fill(0).map(() => Math.floor(Math.random() * 10)).join('');
    
    // 生成邮箱
    const email = `user${i + 1}${Math.floor(Math.random() * 1000)}@example.com`;
    
    // 生成用户状态
    const status = Math.random() > 0.2 ? 'active' : 'inactive';
    
    // 生成头像
    const gender = Math.random() > 0.5 ? 'men' : 'women';
    const avatarId = Math.floor(Math.random() * 99) + 1;
    const avatar = `${avatarBaseUrl}${gender}/${avatarId}.jpg`;
    
    // 根据角色设置相关数据
    let commissionRate = null;
    let totalSales = null;
    let totalCommission = null;
    let walletBalance = 0;
    let withdrawAmount = 0;
    let distributors = [];
    let distributorCount = 0;
    let distributorTotalSales = 0;
    
    if (role === '分销商' || role === '管理员') {
      // 设置佣金比例 (分销商 5-15%, 代理 10-25%)
      commissionRate = role === '分销商' 
        ? Math.floor(Math.random() * 10) + 5 
        : Math.floor(Math.random() * 15) + 10;
      
      // 设置销售额 (分销商 5000-100000, 代理 50000-500000)
      totalSales = role === '分销商'
        ? Math.floor(Math.random() * 95000) + 5000
        : Math.floor(Math.random() * 450000) + 50000;
        
      // 计算累计佣金 (销售额 * 佣金比例 / 100)
      totalCommission = parseFloat((totalSales * commissionRate / 100).toFixed(2));
      
      // 设置钱包余额和提现额
      walletBalance = Math.floor(Math.random() * totalCommission);
      withdrawAmount = Math.random() > 0.8 ? Math.floor(Math.random() * walletBalance) + 100 : 0;
      
      // 如果是代理，则创建下级分销商
      if (role === '管理员') {
        // 创建2-8个分销商
        const distributorNum = Math.floor(Math.random() * 7) + 2;
        
        for (let j = 0; j < distributorNum; j++) {
          // 分销商佣金比例比代理小1-5个百分点
          const distributorCommissionRate = Math.max(3, commissionRate - Math.floor(Math.random() * 5) - 1);
          
          // 生成销售额
          const distributorSales = Math.floor(Math.random() * 47000) + 3000;
          
          // 将分销商添加到列表
          distributors.push({
            id: `DS${j + 1}-${Date.now()}${Math.floor(Math.random() * 1000)}`,
            name: `分销商${j + 1}`,
            phone: '1' + Math.floor(Math.random() * 7 + 3) + Array(9).fill(0).map(() => Math.floor(Math.random() * 10)).join(''),
            sales: distributorSales,
            commissionRate: distributorCommissionRate
          });
          
          // 累计销售额
          distributorTotalSales += distributorSales;
        }
        
        // 更新分销商数量
        distributorCount = distributors.length;
      }
    }
    
    // 注册日期 (1-24个月前)
    const createDate = new Date();
    createDate.setMonth(createDate.getMonth() - Math.floor(Math.random() * 24) - 1);
    
    // 最后登录时间 (最近30天内)
    const lastLoginDate = new Date();
    lastLoginDate.setDate(lastLoginDate.getDate() - Math.floor(Math.random() * 30));
    
    // 格式化日期的函数
    const formatDate = (date) => {
      return date.toISOString().split('T')[0] + ' ' + date.toTimeString().split(' ')[0];
    };
    
    users.push({
      id: `U${i + 1}-${Date.now()}${Math.floor(Math.random() * 1000)}`,
      name,
      avatar,
      role,
      phone,
      email,
      status,
      commissionRate,
      totalSales,
      totalCommission,
      walletBalance,
      withdrawAmount,
      createTime: formatDate(createDate),
      lastLoginTime: formatDate(lastLoginDate),
      address: `示例地址${Math.floor(Math.random() * 1000) + 1}号`,
      distributors,
      distributorCount,
      distributorTotalSales
    });
  }
  
  return users;
}

/**
 * 生成销售趋势数据
 * @param days 天数，默认为7天
 * @returns 销售趋势数据数组
 */
export function generateSalesTrendData(days: number = 7) {
  const result = [];
  const today = new Date();
  
  // 根据指定的天数生成日期和销售数据
  for (let i = days - 1; i >= 0; i--) {
    const date = new Date(today);
    date.setDate(date.getDate() - i);
    
    // 格式化日期为 MM-DD 格式
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const formattedDate = `${month}-${day}`;
    
    // 生成随机销售额（1000-10000之间）
    const sales = Math.floor(Math.random() * 9000) + 1000;
    
    // 生成随机订单数（20-200之间）
    const orders = Math.floor(Math.random() * 180) + 20;
    
    // 去年同期数据（销售额的0.5-1.5倍）
    const lastYearFactor = 0.5 + Math.random();
    const lastYearSales = Math.floor(sales * lastYearFactor);
    
    result.push({
      date: formattedDate,
      sales,
      orders,
      lastYearSales
    });
  }
  
  return result;
}

/**
 * 生成最近活动数据
 * @param count 活动数量，默认为10
 * @returns 最近活动数据数组
 */
export function generateRecentActivitiesData(count: number = 10) {
  const activities = [];
  const now = new Date();
  
  // 活动类型列表
  const activityTypes = [
    '用户注册', '订单创建', '订单支付', '订单发货', '订单完成',
    '提款申请', '提款审核', '提款完成', '产品上架', '产品下架',
    '代理审核', '经销商审核', '系统公告', '佣金结算'
  ];
  
  // 状态列表
  const statusMap = {
    '用户注册': ['成功'],
    '订单创建': ['待支付', '已取消'],
    '订单支付': ['已支付', '支付失败'],
    '订单发货': ['已发货', '待发货'],
    '订单完成': ['已完成', '已取消'],
    '提款申请': ['待审核', '已取消'],
    '提款审核': ['已通过', '已拒绝', '审核中'],
    '提款完成': ['已完成'],
    '产品上架': ['已上架', '待审核'],
    '产品下架': ['已下架'],
    '代理审核': ['已通过', '已拒绝', '待审核'],
    '经销商审核': ['已通过', '已拒绝', '待审核'],
    '系统公告': ['已发布'],
    '佣金结算': ['已结算', '结算中']
  };
  
  // 用户角色列表
  const roles = ['管理员', '分销商', '普通用户', '代理商', '商户'];
  
  // 生成随机活动
  for (let i = 0; i < count; i++) {
    // 随机选择活动类型
    const type = activityTypes[Math.floor(Math.random() * activityTypes.length)];
    
    // 根据活动类型选择状态
    const possibleStatuses = statusMap[type] || ['成功'];
    const status = possibleStatuses[Math.floor(Math.random() * possibleStatuses.length)];
    
    // 随机生成时间（最近24小时内）
    const time = new Date(now.getTime() - Math.floor(Math.random() * 24 * 60 * 60 * 1000));
    
    // 生成随机用户
    const userName = `用户${Math.floor(Math.random() * 1000) + 1}`;
    const role = roles[Math.floor(Math.random() * roles.length)];
    const gender = Math.random() > 0.5 ? 'men' : 'women';
    const avatarId = Math.floor(Math.random() * 99) + 1;
    
    // 生成活动内容
    let content;
    switch (type) {
      case '用户注册':
        content = `新用户 ${userName} 注册成功`;
        break;
      case '订单创建':
        content = `${userName} 创建了新订单 #ORD${Math.floor(Math.random() * 10000)}`;
        break;
      case '订单支付':
        content = `${userName} 支付了订单 #ORD${Math.floor(Math.random() * 10000)}`;
        break;
      case '订单发货':
        content = `订单 #ORD${Math.floor(Math.random() * 10000)} 已发货`;
        break;
      case '订单完成':
        content = `${userName} 的订单 #ORD${Math.floor(Math.random() * 10000)} 已完成`;
        break;
      case '提款申请':
        content = `${userName} 申请提款 ${Math.floor(Math.random() * 1000) + 100}元`;
        break;
      case '提款审核':
        content = `${userName} 的提款申请已${status}`;
        break;
      case '提款完成':
        content = `${userName} 的提款已完成，金额 ${Math.floor(Math.random() * 1000) + 100}元`;
        break;
      case '产品上架':
        content = `新产品 "产品${Math.floor(Math.random() * 100)}" 已上架`;
        break;
      case '产品下架':
        content = `产品 "产品${Math.floor(Math.random() * 100)}" 已下架`;
        break;
      case '代理审核':
        content = `${userName} 的代理申请已${status}`;
        break;
      case '经销商审核':
        content = `${userName} 的经销商申请已${status}`;
        break;
      case '系统公告':
        content = `系统发布了新公告: "${['系统升级通知', '促销活动开始', '佣金比例调整', '新功能上线'][Math.floor(Math.random() * 4)]}"`;
        break;
      case '佣金结算':
        content = `${userName} 的佣金 ${Math.floor(Math.random() * 1000) + 100}元 已结算`;
        break;
      default:
        content = `${userName} 执行了 ${type} 操作`;
    }
    
    // 判断是否需要管理员操作
    const needsAction = Math.random() < 0.3 && ['待审核', '待发货', '审核中'].includes(status);
    
    activities.push({
      id: `act-${Date.now()}-${i}`,
      type,
      time: time.toISOString(),
      timestamp: time.getTime(),
      content,
      user: {
        id: `user-${i}`,
        name: userName,
        role,
        avatar: `https://randomuser.me/api/portraits/${gender}/${avatarId}.jpg`
      },
      status,
      needsAction
    });
  }
  
  // 按时间戳降序排序（最新的在前面）
  activities.sort((a, b) => b.timestamp - a.timestamp);
  
  return activities;
}

/**
 * 生成仪表盘概览数据
 * @returns 仪表盘概览数据对象
 */
export function generateDashboardOverviewData() {
  // 生成随机增长率，范围-20%到40%
  const generateGrowth = () => Math.round((Math.random() * 60 - 20) * 10) / 10;
  
  // 随机生成基础数据，模拟平台统计数据
  const todayOrders = Math.floor(Math.random() * 500) + 100;
  const totalDistributors = Math.floor(Math.random() * 2000) + 500;
  const totalAgents = Math.floor(Math.random() * 300) + 50;
  const totalProducts = Math.floor(Math.random() * 5000) + 1000;
  const todayPaymentAmount = Math.floor(Math.random() * 50000) + 10000;
  const totalRevenue = Math.floor(Math.random() * 10000000) + 1000000;
  const pendingWithdrawAmount = Math.floor(Math.random() * 50000) + 5000;
  const totalWithdrawAmount = Math.floor(Math.random() * 5000000) + 500000;
  
  // 随机生成24小时的订单数据
  const hourlyOrders = Array.from({ length: 24 }, () => Math.floor(Math.random() * 50) + 5);
  
  // 随机生成7天的销售数据
  const dailySales = Array.from({ length: 7 }, () => Math.floor(Math.random() * 100000) + 20000);
  
  // 随机生成用户类型分布
  const userTypeDistribution = {
    agents: Math.floor(Math.random() * 20) + 5,
    distributors: Math.floor(Math.random() * 40) + 20,
    customers: Math.floor(Math.random() * 60) + 40
  };
  
  // 随机生成订单状态分布
  const orderStatusDistribution = {
    pending: Math.floor(Math.random() * 15) + 5,
    processing: Math.floor(Math.random() * 20) + 10,
    shipped: Math.floor(Math.random() * 25) + 15,
    completed: Math.floor(Math.random() * 40) + 30,
    cancelled: Math.floor(Math.random() * 10) + 5
  };
  
  // 随机生成付款方式分布
  const paymentMethodDistribution = {
    creditCard: Math.floor(Math.random() * 40) + 30,
    paypal: Math.floor(Math.random() * 30) + 20,
    bankTransfer: Math.floor(Math.random() * 20) + 10,
    crypto: Math.floor(Math.random() * 15) + 5
  };
  
  return {
    // 基础数据
    todayOrders,
    totalDistributors,
    totalAgents,
    totalProducts,
    todayPaymentAmount,
    totalRevenue,
    pendingWithdrawAmount,
    totalWithdrawAmount,
    
    // 增长数据
    growth: {
      todayOrders: generateGrowth(),
      totalDistributors: generateGrowth(),
      totalAgents: generateGrowth(),
      totalProducts: generateGrowth(),
      todayPaymentAmount: generateGrowth(),
      totalRevenue: generateGrowth(),
      pendingWithdrawAmount: generateGrowth(),
      totalWithdrawAmount: generateGrowth()
    },
    
    // 图表数据
    hourlyOrders,
    dailySales,
    userTypeDistribution,
    orderStatusDistribution,
    paymentMethodDistribution,
    
    // 额外统计
    activeDistributorsPercentage: Math.round(Math.random() * 40 + 60), // 60-100%
    averageOrderValue: Math.floor(Math.random() * 500) + 100,
    averageCommissionRate: Math.round((Math.random() * 10 + 10) * 10) / 10, // 10-20%
    topSellingCategories: [
      { name: '汉堡', value: Math.floor(Math.random() * 1000) + 500 },
      { name: '披萨', value: Math.floor(Math.random() * 900) + 400 },
      { name: '炸鸡', value: Math.floor(Math.random() * 800) + 300 },
      { name: '饮料', value: Math.floor(Math.random() * 700) + 200 },
      { name: '甜点', value: Math.floor(Math.random() * 600) + 100 }
    ]
  };
}

/**
 * 生成商户数据
 * @param count 生成商户的数量
 * @returns 商户数据数组
 */
export function generateMerchantData(count: number = 10) {
  const merchants = [];
  
  // 商户类别
  const categories = ['餐厅', '咖啡厅', '快餐', '火锅', '烧烤', '西餐', '日料', '甜品', '饮品', '小吃'];
  
  // 商户状态
  const statuses = ['active', 'inactive', 'pending'];
  
  // 头像基本URL
  const avatarBaseUrl = 'https://randomuser.me/api/portraits/';
  
  for (let i = 0; i < count; i++) {
    // 生成商户ID
    const merchantId = `M${i + 1}-${Date.now()}${Math.floor(Math.random() * 1000)}`;
    
    // 生成商户名称
    const name = `商户${i + 1}`;
    
    // 随机选择类别
    const category = categories[Math.floor(Math.random() * categories.length)];
    
    // 随机选择状态，大部分是active
    const status = Math.random() > 0.8 
      ? (Math.random() > 0.5 ? 'inactive' : 'pending')
      : 'active';
    
    // 生成商户地址
    const address = `示例市示例区示例路${Math.floor(Math.random() * 100) + 1}号`;
    
    // 生成联系电话
    const phone = '1' + Math.floor(Math.random() * 7 + 3) + Array(9).fill(0).map(() => Math.floor(Math.random() * 10)).join('');
    
    // 生成联系人
    const contactPerson = `负责人${i + 1}`;
    
    // 生成邮箱
    const email = `merchant${i + 1}${Math.floor(Math.random() * 1000)}@example.com`;
    
    // 生成评分 (1-5星)
    const rating = (Math.random() * 4 + 1).toFixed(1);
    
    // 生成注册时间
    const createDate = new Date();
    createDate.setDate(createDate.getDate() - Math.floor(Math.random() * 365));
    
    // 格式化日期
    const formatDate = (date) => {
      return date.toISOString().split('T')[0] + ' ' + date.toTimeString().split(' ')[0];
    };
    
    // 生成商户Logo
    const gender = Math.random() > 0.5 ? 'men' : 'women';
    const avatarId = Math.floor(Math.random() * 99) + 1;
    const logo = `${avatarBaseUrl}${gender}/${avatarId}.jpg`;
    
    // 生成营业时间
    const openHour = Math.floor(Math.random() * 4) + 7; // 7-10点开始营业
    const closeHour = Math.floor(Math.random() * 4) + 20; // 20-23点结束营业
    const businessHours = `${openHour}:00 - ${closeHour}:00`;
    
    // 生成销售数据
    const totalSales = Math.floor(Math.random() * 500000) + 10000;
    const totalOrders = Math.floor(Math.random() * 1000) + 100;
    
    // 生成商品数量
    const productsCount = Math.floor(Math.random() * 50) + 5;
    
    // 生成佣金比例
    const commissionRate = Math.floor(Math.random() * 15) + 5; // 5-20%
    
    // 生成交易量
    const transactionVolume = Math.floor(Math.random() * 10000) + 1000;
    
    // 生成订单数
    const orderCount = Math.floor(Math.random() * 300) + 50;
    
    merchants.push({
      id: merchantId,
      name,
      category,
      status,
      address,
      phone,
      contactPerson,
      email,
      rating,
      createTime: formatDate(createDate),
      logo,
      businessHours,
      totalSales,
      totalOrders,
      productsCount,
      commissionRate,
      description: `这是一家专注于${category}的商户，提供优质的餐饮服务和舒适的用餐环境。`,
      verificationStatus: status === 'active' ? 'verified' : (status === 'pending' ? 'pending' : 'rejected'),
      featured: Math.random() > 0.7, // 30%的概率是推荐商户
      transactionVolume, // 添加交易量字段
      orderCount // 添加订单数字段
    });
  }
  
  return merchants;
}

/**
 * 生成商户产品数据
 * @param merchantId 商户ID
 * @param count 产品数量
 * @returns 产品数据数组
 */
export function generateMerchantProductsData(merchantId: string, count: number = 20) {
  const products = [];
  
  // 产品分类
  const categories = ['主食', '小吃', '饮品', '甜点', '沙拉', '套餐', '招牌菜', '新品', '促销', '季节限定'];
  
  // 产品状态
  const statuses = ['active', 'inactive'];
  
  // 单位类型
  const unitTypes = ['份', '杯', '盘', '碗', '个', '瓶', '包', '袋'];
  
  for (let i = 0; i < count; i++) {
    // 生成产品ID，结合商户ID确保唯一性
    const productId = `p-${merchantId}-${i + 1}-${Date.now()}${Math.floor(Math.random() * 1000)}`;
    
    // 生成产品名称
    const productName = `产品${i + 1}`;
    
    // 随机选择类别
    const category = categories[Math.floor(Math.random() * categories.length)];
    
    // 随机选择状态，大部分是上架状态
    const status = Math.random() > 0.2 ? 'active' : 'inactive';
    
    // 生成原价 (10-200元)
    const originalPrice = Math.floor(Math.random() * 190) + 10;
    
    // 生成折扣价 (有70%的几率有折扣)
    const hasDiscount = Math.random() > 0.3;
    const discountPrice = hasDiscount 
      ? Math.floor(originalPrice * (Math.random() * 0.3 + 0.7)) // 折扣70%-100%
      : null;
    
    // 生成库存数量 (0-999)
    const stock = Math.floor(Math.random() * 1000);
    
    // 生成销售数量 (0-500)
    const sales = Math.floor(Math.random() * 501);
    
    // 生成产品简介
    const descriptions = [
      `美味可口的${category}，深受顾客喜爱。`,
      `特色${category}，采用上等原料制作而成。`,
      `本店招牌${category}，不容错过。`,
      `新鲜出炉的${category}，口感一流。`,
      `经典${category}，百吃不厌。`
    ];
    const description = descriptions[Math.floor(Math.random() * descriptions.length)];
    
    // 生成单位
    const unit = unitTypes[Math.floor(Math.random() * unitTypes.length)];
    
    // 生成规格
    const specifications = [
      '标准',
      '小份',
      '大份',
      '家庭装',
      '迷你装',
      '豪华版',
      '精致装',
      '超值装',
      '单人份',
      '双人份'
    ];
    const specification = specifications[Math.floor(Math.random() * specifications.length)];
    
    // 生成产品图片
    const imageIndex = Math.floor(Math.random() * 100) + 1;
    const imageWidth = 300;
    const imageHeight = 200;
    const image = `https://via.placeholder.com/${imageWidth}x${imageHeight}?text=商品${i + 1}`;
    
    // 生成创建时间
    const createDate = new Date();
    createDate.setDate(createDate.getDate() - Math.floor(Math.random() * 365));
    
    // 生成产品标签
    const tagPool = ['热销', '新品', '推荐', '限时', '优惠', '人气', '精选', '爆款', '招牌', '特价'];
    const tagCount = Math.floor(Math.random() * 3); // 0-2个标签
    const tags = [];
    for (let j = 0; j < tagCount; j++) {
      const randomTagIndex = Math.floor(Math.random() * tagPool.length);
      const tag = tagPool[randomTagIndex];
      tags.push(tag);
      
      // 避免重复标签
      tagPool.splice(randomTagIndex, 1);
    }
    
    // 关联到特定商户ID
    products.push({
      id: productId,
      merchantId: merchantId,
      name: productName,
      category,
      status,
      originalPrice,
      discountPrice,
      stock,
      sales,
      description,
      unit,
      specification,
      image,
      createdAt: createDate.toISOString(),
      updatedAt: new Date().toISOString(),
      tags,
      featured: Math.random() > 0.7, // 30%的概率是推荐产品
      isNew: createDate > new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // 一周内新品
    });
  }
  
  return products;
}

/**
 * 生成商户模拟数据
 * @param count 要生成的商户数量
 * @returns 商户数据数组
 */
export function mockMerchants(count = 20) {
  // 调用已有的generateMerchantData函数生成数据
  return generateMerchantData(count);
}

/**
 * 生成所有产品数据（跨多个商户）
 * @param count 产品总数量
 * @returns 产品数据数组
 */
export function generateAllProductsData(count: number = 50) {
  // 首先生成一些商户数据
  const merchants = generateMerchantData(10);
  const allProducts = [];
  
  // 计算每个商户平均应有的产品数量
  const avgProductsPerMerchant = Math.ceil(count / merchants.length);
  
  // 为每个商户生成产品
  merchants.forEach(merchant => {
    // 为每个商户随机生成不同数量的产品，但总和大致等于count
    const merchantProductCount = Math.min(
      avgProductsPerMerchant + Math.floor(Math.random() * 5) - 2,
      Math.floor(count / 2)  // 确保单个商户的产品不会超过总数的一半
    );
    
    // 使用已有的商户产品生成函数
    const merchantProducts = generateMerchantProductsData(merchant.id, merchantProductCount);
    
    // 添加商户名称到每个产品
    const productsWithMerchantName = merchantProducts.map(product => ({
      ...product,
      merchantName: merchant.name
    }));
    
    // 添加到总产品列表
    allProducts.push(...productsWithMerchantName);
  });
  
  // 如果生成的产品总数少于请求的数量，补充一些产品
  if (allProducts.length < count) {
    const additionalNeeded = count - allProducts.length;
    // 随机选择一些商户来增加产品
    const selectedMerchants = merchants.slice(0, Math.min(3, merchants.length));
    
    for (let i = 0; i < additionalNeeded; i++) {
      const merchant = selectedMerchants[i % selectedMerchants.length];
      const additionalProduct = generateMerchantProductsData(merchant.id, 1)[0];
      
      // 添加商户名称
      additionalProduct.merchantName = merchant.name;
      allProducts.push(additionalProduct);
    }
  }
  
  // 确保不超过请求的数量
  return allProducts.slice(0, count);
}

/**
 * 生成订单数据
 * @param count 生成订单的数量
 * @returns 订单数据数组
 */
export function generateOrdersData(count: number = 50) {
  const orders = [];
  
  // 获取商户数据
  const merchants = generateMerchantData(10);
  
  // 订单状态
  const statuses = ['待付款', '待发货', '已发货', '已完成', '已取消'];
  
  // 支付状态
  const paymentStatuses = ['待支付', '已支付', '已退款', '部分退款', '支付失败'];
  
  // 支付方式
  const paymentMethods = ['微信支付', '支付宝', '银行卡', '余额支付'];
  
  // 快递公司
  const expressCompanies = ['顺丰速运', '中通快递', '圆通速递', '申通快递', '韵达快递', '京东物流'];
  
  for (let i = 0; i < count; i++) {
    // 随机选择一个商户
    const merchant = merchants[Math.floor(Math.random() * merchants.length)];
    
    // 生成订单ID和订单号
    const id = `ORD-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
    const orderNo = `JL${Math.floor(10000000 + Math.random() * 90000000)}`;
    
    // 生成下单时间（过去30天内的随机时间）
    const orderDate = new Date();
    orderDate.setDate(orderDate.getDate() - Math.floor(Math.random() * 30));
    
    // 格式化日期时间
    const formatDateTime = (date) => {
      return date.toISOString().replace('T', ' ').substring(0, 19);
    };
    
    const orderTime = formatDateTime(orderDate);
    
    // 随机订单状态
    const status = statuses[Math.floor(Math.random() * statuses.length)];
    
    // 根据订单状态决定支付状态
    let paymentStatus;
    if (status === '待付款') {
      paymentStatus = '待支付';
    } else if (status === '已取消') {
      paymentStatus = Math.random() > 0.5 ? '已退款' : '待支付';
    } else {
      paymentStatus = '已支付';
    }
    
    // 随机生成支付方式（如果已支付）
    const paymentMethod = paymentStatus === '已支付' ? 
      paymentMethods[Math.floor(Math.random() * paymentMethods.length)] : null;
    
    // 随机生成支付时间（如果已支付）
    const payTime = paymentStatus === '已支付' ? 
      formatDateTime(new Date(orderDate.getTime() + Math.floor(Math.random() * 3600000))) : null;
    
    // 随机生成发货信息（如果已发货或已完成）
    const expressInfo = (status === '已发货' || status === '已完成') ? {
      company: expressCompanies[Math.floor(Math.random() * expressCompanies.length)],
      trackingNo: `SF${Math.floor(1000000000 + Math.random() * 9000000000)}`,
      shipTime: formatDateTime(new Date(orderDate.getTime() + 86400000 + Math.floor(Math.random() * 86400000)))
    } : null;
    
    // 随机生成订单完成时间（如果已完成）
    const completeTime = status === '已完成' ? 
      formatDateTime(new Date(orderDate.getTime() + 172800000 + Math.floor(Math.random() * 172800000))) : null;
    
    // 随机生成取消时间（如果已取消）
    const cancelTime = status === '已取消' ? 
      formatDateTime(new Date(orderDate.getTime() + Math.floor(Math.random() * 86400000))) : null;
    
    // 生成客户信息
    const customerName = `客户${Math.floor(Math.random() * 1000) + 1}`;
    const customerPhone = '1' + Math.floor(Math.random() * 7 + 3) + 
      Array(9).fill(0).map(() => Math.floor(Math.random() * 10)).join('');
    
    // 生成收货地址
    const address = {
      province: ['北京市', '上海市', '广东省', '江苏省', '浙江省'][Math.floor(Math.random() * 5)],
      city: `${['北京', '上海', '广州', '南京', '杭州'][Math.floor(Math.random() * 5)]}市`,
      district: `${['朝阳区', '浦东新区', '天河区', '玄武区', '西湖区'][Math.floor(Math.random() * 5)]}`,
      detail: `示例路${Math.floor(Math.random() * 100) + 1}号`,
      recipient: customerName,
      phone: customerPhone
    };
    
    // 生成订单商品
    const productCount = Math.floor(Math.random() * 5) + 1; // 1-5个商品
    const items = [];
    
    // 生成商品
    const products = generateMerchantProductsData(merchant.id, 20);
    
    let subtotal = 0;
    for (let j = 0; j < productCount; j++) {
      // 随机选择一个商品
      const randomProduct = products[Math.floor(Math.random() * products.length)];
      
      // 随机数量1-5
      const quantity = Math.floor(Math.random() * 5) + 1;
      
      // 计算价格（使用折扣价，如果有的话）
      const price = randomProduct.discountPrice || randomProduct.originalPrice;
      const itemSubtotal = price * quantity;
      
      items.push({
        id: `ITEM-${Date.now()}-${j}`,
        productId: randomProduct.id,
        productName: randomProduct.name,
        price,
        originalPrice: randomProduct.originalPrice,
        quantity,
        subtotal: itemSubtotal,
        productImage: randomProduct.image
      });
      
      subtotal += itemSubtotal;
    }
    
    // 计算其他费用
    const shippingFee = Math.floor(Math.random() * 10) + 5; // 5-15元运费
    const discount = Math.random() > 0.7 ? Math.floor(Math.random() * 20) + 5 : 0; // 30%几率有折扣5-25元
    
    // 计算总价
    const totalAmount = subtotal + shippingFee - discount;
    
    // 创建订单对象
    orders.push({
      id,
      orderNo,
      merchantId: merchant.id,
      merchantName: merchant.name,
      orderTime,
      status,
      paymentStatus,
      paymentMethod,
      payTime,
      expressInfo,
      completeTime,
      cancelTime,
      customerName,
      customerPhone,
      address,
      items,
      subtotal,
      shippingFee,
      discount,
      totalAmount,
      remark: Math.random() > 0.7 ? `订单备注${i + 1}` : ''
    });
  }
  
  // 按下单时间降序排序，最新的订单在前面
  orders.sort((a, b) => new Date(b.orderTime).getTime() - new Date(a.orderTime).getTime());
  
  return orders;
}

/**
 * 生成提现申请数据
 * @param count 生成的提现申请数量
 * @returns 提现申请数据数组
 */
export function generateWithdrawalsData(count: number = 50) {
  const withdrawals = [];
  
  // 创建数据
  const userTypes = ['区域代理', '分销商'];
  const statuses = ['待审核', '已通过', '已拒绝', '已打款'];
  const paymentMethods = ['银行卡', '支付宝', '微信'];
  
  // 银行列表
  const banks = [
    '中国工商银行', '中国农业银行', '中国建设银行', '中国银行', 
    '交通银行', '招商银行', '中信银行', '浦发银行', '民生银行'
  ];
  
  // 头像基本URL
  const avatarBaseUrl = 'https://randomuser.me/api/portraits/';
  
  for (let i = 0; i < count; i++) {
    // 生成ID
    const id = `WD${Date.now()}${Math.floor(Math.random() * 10000)}`;
    
    // 生成用户类型，更大概率是分销商
    const userType = Math.random() > 0.3 ? userTypes[1] : userTypes[0];
    
    // 生成用户名
    const username = `用户${Math.floor(Math.random() * 1000) + 1}`;
    
    // 生成头像
    const gender = Math.random() > 0.5 ? 'men' : 'women';
    const avatarId = Math.floor(Math.random() * 99) + 1;
    const avatar = `${avatarBaseUrl}${gender}/${avatarId}.jpg`;
    
    // 生成申请时间 (过去30天内随机)
    const applyDate = new Date();
    applyDate.setDate(applyDate.getDate() - Math.floor(Math.random() * 30));
    const applicationDate = applyDate.toISOString().substring(0, 10) + ' ' + 
                            applyDate.toTimeString().substring(0, 8);
    
    // 生成提现金额 (100-5000之间)
    const amount = Math.floor(Math.random() * 4900) + 100;
    
    // 生成状态，更多概率是待审核状态
    const statusProbability = Math.random();
    let status;
    if (statusProbability < 0.4) {
      status = statuses[0]; // 待审核
    } else if (statusProbability < 0.7) {
      status = statuses[1]; // 已通过
    } else if (statusProbability < 0.85) {
      status = statuses[3]; // 已打款
    } else {
      status = statuses[2]; // 已拒绝
    }
    
    // 生成支付方式
    const paymentMethod = paymentMethods[Math.floor(Math.random() * paymentMethods.length)];
    
    // 生成账号信息
    let accountNumber, accountName, bankName;
    if (paymentMethod === '银行卡') {
      // 生成银行卡号 (16-19位)
      const cardLength = Math.floor(Math.random() * 4) + 16;
      accountNumber = Array(cardLength).fill(0).map(() => Math.floor(Math.random() * 10)).join('');
      // 银行
      bankName = banks[Math.floor(Math.random() * banks.length)];
      // 持卡人姓名
      accountName = `${username}`;
    } else if (paymentMethod === '支付宝') {
      // 生成支付宝账号 (手机号或邮箱)
      if (Math.random() > 0.5) {
        // 手机号
        accountNumber = '1' + Math.floor(Math.random() * 7 + 3) + 
                        Array(9).fill(0).map(() => Math.floor(Math.random() * 10)).join('');
      } else {
        // 邮箱
        accountNumber = `user${Math.floor(Math.random() * 1000)}@example.com`;
      }
      accountName = username;
      bankName = null;
    } else { // 微信
      // 生成微信号
      accountNumber = `wx_${username.toLowerCase()}${Math.floor(Math.random() * 1000)}`;
      accountName = username;
      bankName = null;
    }
    
    // 生成申请理由
    const reasons = [
      '佣金提现', '收益提现', '平台奖励提现', '活动收益提现', '年终分红提现'
    ];
    const reason = reasons[Math.floor(Math.random() * reasons.length)];
    
    // 生成审核相关信息
    let reviewDate = null;
    let reviewerName = null;
    let reviewRemark = null;
    let transferDate = null;
    
    if (status !== '待审核') {
      // 审核时间是申请时间之后1-24小时
      const reviewTime = new Date(applyDate.getTime() + (Math.floor(Math.random() * 23) + 1) * 3600000);
      reviewDate = reviewTime.toISOString().substring(0, 10) + ' ' + 
                  reviewTime.toTimeString().substring(0, 8);
      reviewerName = `管理员${Math.floor(Math.random() * 10) + 1}`;
      
      if (status === '已拒绝') {
        // 拒绝原因
        const rejectReasons = [
          '账户信息有误', '提现金额超过可用余额', '账户存在异常活动', 
          '提现申请信息不完整', '需要补充其他证明材料'
        ];
        reviewRemark = rejectReasons[Math.floor(Math.random() * rejectReasons.length)];
      } else {
        reviewRemark = '审核通过';
      }
      
      // 如果是已打款状态，生成打款时间
      if (status === '已打款') {
        // 打款时间是审核时间之后1-48小时
        const transferTime = new Date(reviewTime.getTime() + (Math.floor(Math.random() * 47) + 1) * 3600000);
        transferDate = transferTime.toISOString().substring(0, 10) + ' ' + 
                      transferTime.toTimeString().substring(0, 8);
      }
    }
    
    // 推送记录对象
    withdrawals.push({
      id,
      username,
      userType,
      avatar,
      applicationDate,
      amount,
      paymentMethod,
      accountNumber,
      accountName,
      bankName,
      reason,
      status,
      reviewDate,
      reviewerName,
      reviewRemark,
      transferDate,
      remark: Math.random() > 0.7 ? `备注说明${i + 1}` : ''
    });
  }
  
  // 按申请时间逆序排序
  withdrawals.sort((a, b) => 
    new Date(b.applicationDate).getTime() - new Date(a.applicationDate).getTime()
  );
  
  return withdrawals;
}

/**
 * 生成交易记录数据
 * @param count 生成的交易记录数量
 * @returns 交易记录数据数组
 */
export function generateTransactionsData(count: number = 50) {
  const transactions = [];
  
  // 交易类型
  const transactionTypes = ['订单支付', '佣金结算', '提现'];
  
  // 类型对应的颜色
  const typeColors = {
    '订单支付': '#409eff', // 蓝色
    '佣金结算': '#67c23a', // 绿色
    '提现': '#e6a23c' // 橙色
  };
  
  // 交易状态
  const statuses = {
    '订单支付': ['已支付', '退款中', '已退款', '支付失败'],
    '佣金结算': ['已结算', '结算中', '结算失败'],
    '提现': ['已完成', '处理中', '已拒绝']
  };
  
  // 状态对应的颜色
  const statusColors = {
    '已支付': '#67c23a', // 绿色
    '退款中': '#e6a23c', // 橙色
    '已退款': '#409eff', // 蓝色
    '支付失败': '#f56c6c', // 红色
    '已结算': '#67c23a', // 绿色
    '结算中': '#e6a23c', // 橙色
    '结算失败': '#f56c6c', // 红色
    '已完成': '#67c23a', // 绿色
    '处理中': '#e6a23c', // 橙色
    '已拒绝': '#f56c6c' // 红色
  };
  
  // 用户类型
  const userTypes = ['区域代理', '分销商', '普通用户'];
  
  // 生成交易记录
  for (let i = 0; i < count; i++) {
    // 生成交易ID
    const id = `TX${Date.now()}${Math.floor(Math.random() * 10000)}`;
    
    // 生成交易时间（过去30天内）
    const transactionDate = new Date();
    transactionDate.setDate(transactionDate.getDate() - Math.floor(Math.random() * 30));
    
    // 格式化日期和时间
    const dateStr = transactionDate.toISOString().split('T')[0];
    const timeStr = transactionDate.toTimeString().substring(0, 8);
    
    // 随机选择交易类型
    const transactionType = transactionTypes[Math.floor(Math.random() * transactionTypes.length)];
    
    // 根据交易类型选择状态
    const possibleStatuses = statuses[transactionType];
    const status = possibleStatuses[Math.floor(Math.random() * possibleStatuses.length)];
    
    // 默认是支出流向
    let flow = 'expense';
    
    // 根据交易类型和用户类型决定资金流向
    if (transactionType === '佣金结算') {
      flow = 'income'; // 对平台来说是支出，对用户来说是收入
    }
    
    // 生成交易金额
    let amount;
    switch (transactionType) {
      case '订单支付':
        amount = Math.floor(Math.random() * 500) + 50; // 50-550元
        break;
      case '佣金结算':
        amount = Math.floor(Math.random() * 200) + 20; // 20-220元
        break;
      case '提现':
        amount = Math.floor(Math.random() * 1000) + 100; // 100-1100元
        break;
      default:
        amount = Math.floor(Math.random() * 100) + 10; // 10-110元
    }
    
    // 根据交易类型设置用户类型
    let userType;
    if (transactionType === '佣金结算' || transactionType === '提现') {
      userType = Math.random() > 0.3 ? userTypes[1] : userTypes[0]; // 多为分销商
    } else {
      userType = userTypes[Math.floor(Math.random() * userTypes.length)];
    }
    
    // 生成用户名
    const username = `用户${Math.floor(Math.random() * 1000) + 1}`;
    
    // 生成关联订单（仅当交易类型为订单支付时）
    const relatedOrder = transactionType === '订单支付' ? 
      `JL${Math.floor(10000000 + Math.random() * 90000000)}` : null;
    
    // 生成关联提现单号（仅当交易类型为提现时）
    const relatedWithdrawal = transactionType === '提现' ? 
      `WD${Math.floor(Math.random() * 1000000)}` : null;
    
    // 生成备注信息
    let remark;
    switch (transactionType) {
      case '订单支付':
        remark = `订单${relatedOrder}支付`;
        break;
      case '佣金结算':
        remark = `${userType}佣金结算`;
        break;
      case '提现':
        remark = `${userType}提现申请${relatedWithdrawal}`;
        break;
      default:
        remark = '其他交易';
    }
    
    // 创建交易记录对象
    transactions.push({
      id,
      transactionDate: dateStr,
      transactionTime: timeStr,
      transactionType,
      typeColor: typeColors[transactionType],
      status,
      statusColor: statusColors[status],
      amount,
      flow,
      username,
      userType,
      relatedOrder,
      relatedWithdrawal,
      remark,
      paymentMethod: transactionType === '订单支付' ? 
        ['微信支付', '支付宝', '银行卡'][Math.floor(Math.random() * 3)] : null,
      platformFee: transactionType === '订单支付' ? 
        (amount * (Math.random() * 0.05 + 0.02)).toFixed(2) : null, // 平台服务费2%-7%
      settlementBatch: transactionType === '佣金结算' ? 
        `BATCH${Math.floor(Math.random() * 1000000)}` : null
    });
  }
  
  // 按交易时间排序
  transactions.sort((a, b) => {
    const dateA = new Date(`${a.transactionDate} ${a.transactionTime}`);
    const dateB = new Date(`${b.transactionDate} ${b.transactionTime}`);
    return dateB.getTime() - dateA.getTime(); // 降序，最新的在前
  });
  
  return transactions;
}

/**
 * 生成用户销售数据
 * @param userId 用户ID
 * @param days 天数
 * @returns 用户销售数据
 */
export function generateUserSalesData(userId: string, days: number = 30) {
  // 生成每日销售数据
  const salesData = [];
  const now = new Date();
  
  // 生成随机的佣金比率
  const commissionRate = Math.floor(Math.random() * 15) + 10; // 佣金比率在10%到25%之间
  
  let totalSales = 0;
  let totalCommission = 0;
  
  // 生成过去days天的销售数据
  for (let i = days - 1; i >= 0; i--) {
    const date = new Date(now);
    date.setDate(date.getDate() - i);
    
    // 格式化日期为YYYY-MM-DD
    const formattedDate = date.toISOString().split('T')[0];
    
    // 生成随机销售额，1000-10000之间
    const sales = Math.floor(Math.random() * 9000) + 1000;
    
    // 计算佣金
    const commission = Math.round(sales * commissionRate / 100);
    
    salesData.push({
      date: formattedDate,
      sales,
      commission,
      orders: Math.floor(Math.random() * 20) + 1 // 1-20个订单
    });
    
    totalSales += sales;
    totalCommission += commission;
  }
  
  return {
    userId,
    salesData,
    totalSales,
    totalCommission,
    commissionRate
  };
}

/**
 * 生成用户订单数据
 * @param userId 用户ID
 * @param count 要生成的订单数量
 * @returns 用户订单数据数组
 */
export function generateUserOrdersData(userId: string, count: number = 15) {
  const orderStatuses = ['已完成', '配送中', '已付款', '已取消'];
  const productNames = [
    '特级金料牛肉500g',
    '精选金料猪肉300g',
    '优质金料羊肉250g',
    '新鲜金料鸡胸肉400g',
    '金料特级牛排2片装',
    '金料精品礼盒装',
    '金料豪华烤肉套餐',
    '金料家庭组合装'
  ];
  
  const result = [];
  
  // 生成过去一个月的日期范围
  const now = new Date();
  const oneMonthAgo = new Date();
  oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
  
  for (let i = 0; i < count; i++) {
    // 生成随机日期
    const orderDate = new Date(
      oneMonthAgo.getTime() + Math.random() * (now.getTime() - oneMonthAgo.getTime())
    );
    
    // 随机产品数量（1-3个产品）
    const productCount = Math.floor(Math.random() * 3) + 1;
    let productSummary = '';
    let totalAmount = 0;
    
    // 生成订单中的产品
    for (let j = 0; j < productCount; j++) {
      const productName = productNames[Math.floor(Math.random() * productNames.length)];
      const quantity = Math.floor(Math.random() * 3) + 1;
      const price = Math.floor(Math.random() * 100) + 50; // 50-150元
      
      productSummary += `${productName} x${quantity}`;
      if (j < productCount - 1) {
        productSummary += '、';
      }
      
      totalAmount += price * quantity;
    }
    
    // 随机状态
    const status = orderStatuses[Math.floor(Math.random() * orderStatuses.length)];
    
    // 计算佣金（约为订单金额的5-15%）
    const commissionRate = 0.05 + Math.random() * 0.1;
    const commission = totalAmount * commissionRate;
    
    // 生成订单编号
    const orderId = `JL${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${i.toString().padStart(6, '0')}`;
    
    result.push({
      id: orderId,
      userId,
      date: orderDate.toISOString(),
      productSummary,
      amount: totalAmount,
      commission,
      status,
      products: Array(productCount).fill(null).map((_, index) => ({
        name: productNames[(index + Math.floor(Math.random() * 3)) % productNames.length],
        quantity: Math.floor(Math.random() * 3) + 1,
        price: Math.floor(Math.random() * 100) + 50
      }))
    });
  }
  
  // 按日期从新到旧排序
  return result.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
}

/**
 * 生成用户佣金数据
 * @param userId 用户ID
 * @param count 要生成的佣金记录数量
 * @returns 用户佣金记录数组
 */
export function generateUserCommissionData(userId: string, count: number = 15) {
  const commissionStatuses = ['待结算', '可提现', '已提现'];
  const productNames = [
    '特级金料牛肉500g',
    '精选金料猪肉300g',
    '优质金料羊肉250g',
    '新鲜金料鸡胸肉400g',
    '金料特级牛排2片装',
    '金料精品礼盒装',
    '金料豪华烤肉套餐',
    '金料家庭组合装'
  ];
  
  const result = [];
  
  // 生成过去一个月的日期范围
  const now = new Date();
  const oneMonthAgo = new Date();
  oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
  
  for (let i = 0; i < count; i++) {
    // 生成随机创建日期
    const createdDate = new Date(
      oneMonthAgo.getTime() + Math.random() * (now.getTime() - oneMonthAgo.getTime())
    );
    
    // 随机选择一个状态
    const status = commissionStatuses[Math.floor(Math.random() * commissionStatuses.length)];
    
    // 随机产品数量（1-2个产品）
    const productCount = Math.floor(Math.random() * 2) + 1;
    let productSummary = '';
    
    // 生成订单中的产品
    for (let j = 0; j < productCount; j++) {
      const productName = productNames[Math.floor(Math.random() * productNames.length)];
      const quantity = Math.floor(Math.random() * 3) + 1;
      
      productSummary += `${productName} x${quantity}`;
      if (j < productCount - 1) {
        productSummary += '、';
      }
    }
    
    // 佣金金额（50-500元）
    const amount = Math.floor(Math.random() * 450) + 50;
    
    // 生成结算日期（如果状态是"已提现"）
    let settlementDate = null;
    if (status === '已提现') {
      // 结算日期应该在创建日期之后
      const minSettlementDate = new Date(createdDate.getTime() + 24 * 60 * 60 * 1000); // 至少一天后
      const maxSettlementDate = new Date();
      settlementDate = new Date(
        minSettlementDate.getTime() + 
        Math.random() * (maxSettlementDate.getTime() - minSettlementDate.getTime())
      );
    }
    
    // 生成记录ID和订单ID
    const recordId = `CM${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${i.toString().padStart(6, '0')}`;
    const orderId = `JL${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${i.toString().padStart(6, '0')}`;
    
    result.push({
      id: recordId,
      userId,
      orderId,
      createdAt: createdDate.toISOString(),
      productSummary,
      amount,
      status,
      settlementDate: settlementDate ? settlementDate.toISOString() : null
    });
  }
  
  // 按日期从新到旧排序
  return result.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
}

/**
 * 生成用户详细信息数据
 * @param userId 用户ID
 * @returns 用户详细信息数据对象
 */
export function generateUserDetailData(userId: string) {
  // 生成随机头像URL
  const avatarId = parseInt(userId.replace(/\D/g, '')) % 100;
  const avatar = `https://randomuser.me/api/portraits/${avatarId % 2 === 0 ? 'men' : 'women'}/${avatarId}.jpg`;
  
  // 随机决定用户角色
  const roleIndex = parseInt(userId.substring(userId.length - 1)) % 3;
  const roles = ['普通用户', '分销商', '区域代理'];
  const role = roles[roleIndex];
  
  // 生成基础用户数据
  const user = {
    id: userId,
    name: `用户${userId.slice(-4)}`,
    role: role,
    phone: `1${Math.floor(Math.random() * 9) + 3}${Array.from({ length: 9 }, () => Math.floor(Math.random() * 10)).join('')}`,
    email: `user${userId.slice(-4)}@example.com`,
    avatar: avatar,
    status: Math.random() > 0.2 ? '活跃' : '停用',
    createTime: new Date(Date.now() - Math.floor(Math.random() * 1000 * 60 * 60 * 24 * 365)).toISOString(),
    lastLoginTime: new Date(Date.now() - Math.floor(Math.random() * 1000 * 60 * 60 * 24 * 30)).toISOString(),
    address: {
      province: ['北京市', '上海市', '广东省', '江苏省', '浙江省'][Math.floor(Math.random() * 5)],
      city: ['朝阳区', '浦东新区', '广州市', '南京市', '杭州市'][Math.floor(Math.random() * 5)],
      detail: `某某路${Math.floor(Math.random() * 100) + 1}号`
    },
    remark: Math.random() > 0.5 ? `这是用户${userId}的备注信息，${Math.random() > 0.5 ? '重要客户' : '普通客户'}。` : '',
  };
  
  // 根据角色添加不同的数据
  if (role === '分销商' || role === '区域代理') {
    // 佣金率（5-20%）
    const commissionRate = Math.floor(Math.random() * 16) + 5;
    
    // 钱包余额和提现金额
    const walletBalance = Math.floor(Math.random() * 10000) + 1000;
    const withdrawAmount = Math.floor(Math.random() * 50000) + 5000;
    
    // 销售和佣金数据
    const totalOrders = Math.floor(Math.random() * 200) + 50;
    const totalSales = Math.floor(Math.random() * 100000) + 10000;
    const totalCommission = Math.floor(totalSales * commissionRate / 100);
    
    // 合并分销商/代理特有的数据
    Object.assign(user, {
      commissionRate: commissionRate,
      walletBalance: walletBalance,
      withdrawAmount: withdrawAmount,
      totalOrders: totalOrders,
      totalSales: totalSales,
      totalCommission: totalCommission,
      monthlySales: Array.from({ length: 6 }, () => Math.floor(Math.random() * 20000) + 1000),
      monthlyCommission: Array.from({ length: 6 }, () => Math.floor(Math.random() * 4000) + 200),
    });
    
    // 如果是区域代理，添加分销商数据
    if (role === '区域代理') {
      const distributorCount = Math.floor(Math.random() * 20) + 5;
      const distributorTotalSales = Math.floor(Math.random() * 500000) + 50000;
      
      // 生成分销商列表
      const distributors = Array.from({ length: distributorCount }, (_, index) => {
        const distributorSales = Math.floor(Math.random() * 50000) + 5000;
        const distributorCommission = Math.floor(distributorSales * 0.1); // 假设分销商佣金率为10%
        return {
          id: `D${userId}${index + 1}`,
          name: `分销商${index + 1}`,
          sales: distributorSales,
          commission: distributorCommission,
          joinDate: new Date(Date.now() - Math.floor(Math.random() * 1000 * 60 * 60 * 24 * 180)).toISOString()
        };
      });
      
      // 合并区域代理特有的数据
      Object.assign(user, {
        distributorCount: distributorCount,
        distributorTotalSales: distributorTotalSales,
        distributors: distributors
      });
    }
  }
  
  return user;
} 